#include "app_device.h"
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <pthread.h>
#include "app_mqtt.h"
#include "app_buffer.h"
#include "log.h"
#include "app_pool.h"
#include "app_message.h"
#include <stdio.h>
#include <fcntl.h>
#include "app_common.h"

static app_device_t *device;
/**
 * @brief 设备模块初始化
 *  // 0  创建设备模块结构体
 * // 1  打开文件
 *  // 2  初始化缓冲区
 *  // 3  预处理的初始值NULL
 */

app_device_t *app_device_init(void)
{
    // 0  创建设备模块结构体
    device = malloc(sizeof(app_device_t));
    // 1  打开文件
    device->dev_filename = DEVICE_FILENAME;
    device->dev_fd = open(device->dev_filename, O_RDWR);
    if (device->dev_fd < 0)
    {
        perror("打开文件失败");
        return NULL;
    }
    // 2  初始化缓冲区
    device->up_buffer = app_buffer_init();
    device->down_buffer = app_buffer_init();

    // 3  预处理的初始值NULL
    device->post_read = NULL;
    device->pre_write = NULL;
    // 4 其他
    device->read_thread = -1;
    device->conn_type = 1;

    // 返回
    return device;
}

/**
 * @brief 设备模块的上行2 通路
  1 从缓冲区读取数据
  2 进行数据转换 json
  3 发送mqtt模块(发送网络)
 */
static void *app_device_up_2_send(void *arg)
{
    // 1 从缓冲区读取数据
    char read_buff[100];
    int read_size = app_buffer_read(device->up_buffer, read_buff, 100);
    if (read_size > 0)
    {
        log_info("设备模块从缓冲区读取数据成功");
    }
    // 2 进行数据转换 json
    char *json = app_message_bytes_to_json(read_buff, read_size);
    if (strlen(json) > 0)
    {
        log_info("转换数据成功");
    }
    // 3 发送mqtt模块(发送网络)
    app_mqtt_publish(json);

    return NULL;
}

/**
 * @brief 设备模块的上行1 通路
 * 1 设备文件读取数据read
2 读后预处理（蓝牙格式->字节数组）
3 写入到上行缓冲区
4 提交后续任务到线程池

 *
 */
static void *app_device_up_1_read(void *arg)
{
    // * 1 设备文件读取数据read
    char read_buff[20];
    while (1)
    {
        int read_size = read(device->dev_fd, read_buff, 20);
        if (read_size < 0)
        {
            log_error("设备文件读取数据read失败");
            continue;
        }
        else if (read_size == 0)
        {
            continue;
        }
        log_info("设备文件读取数据read成功,数据长度%d", read_size);
        app_common_print_hex(read_buff, read_size);

        // 2 读后预处理（蓝牙格式->字节数组）
        if (device->post_read)
        {
            read_size = device->post_read(read_buff, read_size);
            log_info("设备文件读取数据post_read成功,数据长度%d", read_size);
            app_common_print_hex(read_buff, read_size);
        }
        // 3 写入到上行缓冲区
        if (read_size > 0)
        {   
            
            int ret = app_buffer_write(device->up_buffer, read_buff, read_size);
            if (ret == 0)
            {
                log_info("设备模块写入到上行缓冲区成功");
            }
            // 4 提交后续任务到线程池
            app_pool_submit_task(app_device_up_2_send, NULL);
            log_info("数据提交到线程池成功");
        }
    }
    return NULL;
}

/**
 * @brief 设备模块的下行2 通路
 *1 从缓冲区读取数据
  2 写前预处理(转为蓝牙格式)
  3 写入到蓝牙模块 write

 */
static void *app_device_down_2_write(void *arg)
{ 

    // *1 从缓冲区读取数据
    char data_buff[100];
    int data_size= app_buffer_read(device->down_buffer, data_buff, 100);
    if (data_size > 0)
    {
        log_info("设备模块从缓冲区读取数据成功");
    }
    // 2 写前预处理(转为蓝牙格式)
    if (device->pre_write)
    {
        data_size = device->pre_write(data_buff, data_size);
        log_info("设备文件读取数据pre_write成功,数据长度%d", data_size);
        app_common_print_hex(data_buff, data_size);

    }
    // 3 写入到蓝牙模块 write
    if (data_size > 0)
    {
        log_info("待写入数据：");
        app_common_print_hex(data_buff, data_size);
    }
    write(device->dev_fd, data_buff, data_size);
    log_info("设备模块写入蓝牙模块成功");
    return NULL;

}


/**
 * @brief 设备模块的下行1 通路
 * 1 数据转换  字节数组 
   2 写入下行缓冲区 
   3 提交后续任务到线程池
 */
static int app_device_down_1_recv(char *json)
{
    log_info("设备模块收到数据:%s", json);
    // * 1 数据转换  字节数组 
    char  buff[100];
    int data_size= app_message_json_to_bytes(json, buff ,100);
    if(data_size>0)
    {
        log_info("转换数据成功");
    }
    // 2 写入下行缓冲区 
    int ret=  app_buffer_write(device->down_buffer, buff, data_size);
    if(ret==0)
    {
        log_info("设备模块写入到下行缓冲区成功");
    }

    // 3 提交后续任务到线程池
    app_pool_submit_task(app_device_down_2_write, NULL);
    log_info("提交到线程池成功");
    return 0;
}

/**
 * @brief 设备模块启动
   //1  创建读取线程  (启动上行通路)
   //2 向mqtt模块注册接收数据的回调( 启动下行通路)
   @return 0 成功 -1 失败
 */
int app_device_start(void)
{
    // 1  创建读取线程  (启动上行通路)
    pthread_create(&device->read_thread, NULL, app_device_up_1_read, NULL);
    // 2 向mqtt模块注册接收数据的回调( 启动下行通路)
    app_mqtt_register_recv_callback(app_device_down_1_recv);

    return 0;
}

/**
 * @brief 设备模块销毁
 */
void app_device_destroy(void)
{   
    // 1  销毁读取线程 
    pthread_cancel(device->read_thread);
    pthread_join(device->read_thread, NULL);
    // 2  销毁缓冲区
    app_buffer_destroy(device->up_buffer);
    app_buffer_destroy(device->down_buffer);
    // 3 关闭文件
    close(device->dev_fd);
    // 4 结构体释放 
    free(device);

}
